home *** CD-ROM | disk | FTP | other *** search
/ Trusted Irix /B 4.0.4 / Trusted-Irix B-4.0.1.iso / dist / eoe1.idb / usr / include / sys / fs / efs_fs.h.z / efs_fs.h
C/C++ Source or Header  |  1992-04-03  |  7KB  |  177 lines
  1. #ifndef    __efs_fs_
  2. #define    __efs_fs_
  3. /*
  4.  * An extent filesystem is composed of some number of basic blocks.  A basic
  5.  * block is composed of one disk sector (512 bytes).  The term
  6.  * "bb" is used as short hand for a basic block.
  7.  *
  8.  * The superblock is replicated for robustness in IRIX 3.3 and beyond.
  9.  * The replicated superblock is on the very last block of the storage where
  10.  * the filesystem resides. For convenience, a new field 'fs_replsb' (claimed
  11.  * from the area of spare fields) points to its location.
  12.  *
  13.  * Filesystems may be GROWN in IRIX 3.3 and beyond. To do this, the bitmap
  14.  * for the newly expanded filesystem is moved to the END of the storage space 
  15.  * (just before the replicated superblock), to avoid overlapping the first 
  16.  * cylinder group.
  17.  * It is then located via a pointer fs_bmblock in the superblock. 
  18.  * The space formerly occupied by the bitmap at block 2 becomes unused.
  19.  * Note that grown filesytems have a new fs magic number to enable tools
  20.  * and the kernel to handle the different layout.
  21.  * Filesystems from any IRIX release may be grown, and filesystems
  22.  * may be grown repreatedly (by simply repeating the process of taking the
  23.  * bitmap to the end); note however that a grown filesystem can NOT be used
  24.  * with pre-3.3 kernels or tools.
  25.  *
  26.  * Physical layout of a normal efs:
  27.  *    1. Basic block 0 is unused.
  28.  *    2. Basic block 1 is the efs superblock.
  29.  *    3. Basic block 2 begins the bitmap.  The bitmap covers
  30.  *       Basic blocks 2 through 2 + BTOD(fs->fs_bmsize) - 1, inclusively.
  31.  *    4. Between the end of the bitmap and the basic block fs->fs_firstcg
  32.  *       are some number of unused basic blocks (left unused for alignment
  33.  *       reasons).  fs->fs_firstcg specifies the start of the first cylinder 
  34.  *       group, in basic blocks.
  35.  *    5. Beginning at fs->fs_firstcg are fs->fs_ncg's worth of cylinder
  36.  *       groups.  The cylinder group size is fs->fs_cgfsize basic blocks.
  37.  *       Each cylinder group contains fs->fs_cgisize worth of inode basic
  38.  *       blocks.  The remaining basic blocks in the cylinder group are
  39.  *       data blocks.
  40.  *    6. At the end of the filesystem, just past the end of the last
  41.  *       cylinder group are (usually) some number of trailing disk sectors,
  42.  *       left unused for alignment reasons.
  43.  *    7. In 3.3 and beyond, the very last block of the filesystem space
  44.  *       is a replica of the superblock. (3.3.fsck will attempt to
  45.  *       retrofit a replicated superblock to earlier filesystems if
  46.  *       space permits). If present, fs->fs_replsb points to this.
  47.  *
  48.  * Physical layout of a grown efs:
  49.  *    1. Basic block 0 is unused.
  50.  *    2. Basic block 1 is the efs superblock.
  51.  *    3. Between the superblock and the basic block fs->fs_firstcg
  52.  *       are some number of unused basic blocks.  fs->fs_firstcg specifies
  53.  *       the start of the first cylinder group, in basic blocks.
  54.  *    4. Beginning at fs->fs_firstcg are fs->fs_ncg's worth of cylinder
  55.  *       groups.  The cylinder group size is fs->fs_cgfsize basic blocks.
  56.  *       Each cylinder group contains fs->fs_cgisize worth of inode basic
  57.  *       blocks.  The remaining basic blocks in the cylinder group are
  58.  *       data blocks.
  59.  *    5. After the last cylinder group, before the bitmap, there will usually
  60.  *       be some number of unused basic blocks (a consequence of alignment).
  61.  *    6. At the end of the filesystem space, BTOD(fs->fs_bmsize) blocks
  62.  *       constitute the bitmap. fs->fs_bmblock points to the start of this,
  63.  *       it ends one block short of the end of storage.
  64.  *    7. The very last block of the space is the replicated superblock.
  65.  *       fs->fs_replsb points to this.
  66.  *
  67.  * How the layout is parameterized in the superblock:
  68.  *
  69.  *    In a regular, non-grown efs:
  70.  *       The size of the filesystem in basic blocks, excluding the trailing
  71.  *       basic blocks after the last cylinder group, is contained in
  72.  *       fs->fs_size.
  73.  *
  74.  *    In a grown efs:
  75.  *       fs->fs_size contains ALL blocks used by the filesystem, including
  76.  *       the bitmap & replicated superblock at the end. 
  77.  *       It's unfortunate that we had to change this, but alas pre-3.3
  78.  *       fsck does NOT look at the magic number; this was the ONLY way
  79.  *       to lock a pre-3.3 fsck out of running on a grown filesystem!
  80.  *
  81.  * Caveats:
  82.  *    1. Trying to change the parameterization of the basic block size
  83.  *       probably won't work.
  84.  *
  85.  */
  86.  
  87. /*
  88.  * Locations of the efs superblock, bitmap and root inode.
  89.  */
  90. #define    EFS_SUPERBB    ((daddr_t)1)        /* bb # of the superblock */
  91. #define    EFS_BITMAPBB    ((daddr_t)2)         /* bb of the bitmap, pre 3.3*/
  92. #define    EFS_SUPERBOFF    BBTOB(EFS_SUPERBB)    /* superblock byte offset */
  93. #define    EFS_BITMAPBOFF    BBTOB(EFS_BITMAPBB)    /* bitmap byte offset */
  94. #define    EFS_ROOTINO    ((ino_t)2)        /* where else... */
  95.  
  96. /*
  97.  * Inode parameters.
  98.  */
  99. /* number of inodes per bb */
  100. #define    EFS_INOPBB    (1 << EFS_INOPBBSHIFT)
  101. #define    EFS_INOPBBSHIFT    (BBSHIFT - EFS_EFSINOSHIFT)
  102. #define    EFS_INOPBBMASK    (EFS_INOPBB - 1)
  103.  
  104. /*
  105.  * This macro initializes the computable fields of the efs superblock so
  106.  * as to insure that the macros that use these fields will work.  It's other
  107.  * purpose is to allow the macros to use the computable fields so that they
  108.  * are simpler.  This macro should be executed, whenever a program wishes
  109.  * to manipulate the filesystem, before actually manipulating the filesystem.
  110.  */
  111. #define    EFS_SETUP_SUPERB(fs) \
  112.     { \
  113.         (fs)->fs_ipcg = EFS_COMPUTE_IPCG(fs); \
  114.     }
  115.  
  116. /*
  117.  * Compute the number of inodes-per-cylinder-group (IPCG) and the number
  118.  * of inodes-per-basic-block (INOPBB).
  119.  */
  120. #define    EFS_COMPUTE_IPCG(fs) \
  121.     ((short) ((fs)->fs_cgisize << EFS_INOPBBSHIFT))
  122.  
  123. /*
  124.  * Layout macros.  These macro provide easy access to the layout by
  125.  * translating between sectors, basic blocks, and inode numbers.
  126.  * WARNING: The macro EFS_SETUP_SUPERB must be executed before most
  127.  * of these macros!
  128.  */
  129.  
  130. /* inode number to bb, relative to cylinder group */
  131. #define    EFS_ITOCGBB(fs, i) \
  132.     ((daddr_t) (((i) >> EFS_INOPBBSHIFT) % (fs)->fs_cgisize))
  133.  
  134. /* inode number to offset from bb base */
  135. #define    EFS_ITOO(fs, i) \
  136.     ((short) ((i) & EFS_INOPBBMASK))
  137.  
  138. /* inode number to cylinder group */
  139. #define    EFS_ITOCG(fs, i) \
  140.     ((short) ((i) / (fs)->fs_ipcg))
  141.  
  142. /* inode number to cylinder group inode number offset */
  143. #define    EFS_ITOCGOFF(fs, i) \
  144.     ((short) ((i) % (fs)->fs_ipcg))
  145.  
  146. /* inode number to disk bb number */
  147. #define    EFS_ITOBB(fs, i) \
  148.     ((daddr_t) ((fs)->fs_firstcg + \
  149.             (EFS_ITOCG(fs, i) * (fs)->fs_cgfsize) + \
  150.             EFS_ITOCGBB(fs, i)))
  151.  
  152. /* bb to cylinder group number */
  153. #define    EFS_BBTOCG(fs, bb) \
  154.     ((short) ((bb - (fs)->fs_firstcg) / (fs)->fs_cgfsize))
  155.  
  156. /* cylinder group number to disk bb of base of cg */
  157. #define    EFS_CGIMIN(fs, cg) \
  158.     ((daddr_t) ((fs)->fs_firstcg + (cg) * (fs)->fs_cgfsize))
  159.  
  160. /* inode number to base inode number in its chunk */
  161. #define    EFS_ITOCHUNKI(fs, cg, inum) \
  162.     (((((inum) - (cg)->cg_firsti) / (fs)->fs_inopchunk) * \
  163.       (fs)->fs_inopchunk) + (cg)->cg_firsti)
  164.  
  165. /*
  166.  * Allocation parameters.  EFS_MINFREE is based on the unix typical
  167.  * file size - less than 1k.  EFS_MINDIRFREE is based on a guess as
  168.  * to the typical number of those less than 1k files per directory.
  169.  * EFS_ICHUNKSIZE is just a good number for the given hardware.
  170.  */
  171. #define    EFS_MINFREEBB        2
  172. #define    EFS_MINDIRFREEBB    (10 * 2)
  173. #define    EFS_INOPCHUNK        (NBPC / sizeof(struct efs_dinode))
  174. #define EFS_INOPCHUNKBB        (EFS_INOPCHUNK / EFS_INOPBB)
  175.  
  176. #endif    /* __efs_fs_ */
  177.